
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package itm.dao.proyectosInvestigacion;

//~--- non-JDK imports --------------------------------------------------------
import itm.exception.DAOException;
import itm.exception.ProyectoInvestigacionDAOException;
import itm.vo.convocatorias.ConvocatoriaVO;
import itm.vo.file.ArchivoVO;
import itm.vo.grupoInvestigacion.GrupoInvestigacionVO;
import itm.vo.grupoInvestigacion.RolVO;
import itm.vo.lineaInvestigacion.LineaInvestigacionVO;
import itm.vo.personas.PersonaVO;
import itm.vo.proyectosInvestigacion.ActividadProyectoVO;
import itm.vo.proyectosInvestigacion.AvanceActividadVO;
import itm.vo.proyectosInvestigacion.CriterioEstadoProyecto;
import itm.vo.proyectosInvestigacion.CriterioEvaluacionVO;
import itm.vo.proyectosInvestigacion.CriterioObservacionVO;
import itm.vo.proyectosInvestigacion.EvaluacionCalidadProyectoVO;
import itm.vo.proyectosInvestigacion.EvaluacionProyectoVO;
import itm.vo.proyectosInvestigacion.EvaluadorProyectoVO;
import itm.vo.proyectosInvestigacion.FasesVO;
import itm.vo.proyectosInvestigacion.FuenteFinanciacionVO;
import itm.vo.proyectosInvestigacion.ProyectoInvestigacionVO;
import itm.vo.proyectosInvestigacion.TipoInvestigacionVO;

//~--- JDK imports ------------------------------------------------------------

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Administrador
 */
public class ProyectoInvestigacionDAO {

    private CallableStatement callStmt = null;
    private ResultSet res = null;
    private String sql = "";
    Connection dbConexion;

    public ProyectoInvestigacionDAO(Connection dbConexion) throws SQLException {
        this.dbConexion = dbConexion;
    }

    public String asignarAval(ProyectoInvestigacionVO proyectoInvVO) {
        String respuesta = "";

        try {
            sql = "{call ITM_ASIGNAR_AVAL_PROYECTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, proyectoInvVO.getIdProyecto());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String asignarEvaluador(EvaluadorProyectoVO evaluadorAsignadoVO) {
        String respuesta = "";

        try {
            sql = "{call ITM_ASIGNAR_EVALUADOR_PROYECTO(?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, evaluadorAsignadoVO.getIdPersona());
            callStmt.setInt(3, evaluadorAsignadoVO.getIdProyecto());
            callStmt.setString(4, evaluadorAsignadoVO.getTipoEvaluador());
            callStmt.setDate(5, evaluadorAsignadoVO.getFechaAsignacion());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public List<ActividadProyectoVO> consultarActividadesProyecto(ProyectoInvestigacionVO proyectoVO) {
        List<ActividadProyectoVO> listaActividades = new ArrayList<ActividadProyectoVO>();
        ActividadProyectoVO actividadVO;

        try {
            sql = "{call ITM_CONSULTAR_ACTIVIDADES_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                actividadVO = new ActividadProyectoVO();
                actividadVO.setIdActividad(res.getInt(1));
                actividadVO.setIdProyecto(res.getInt(2));
                actividadVO.setNombreActividad(res.getString(3));
                actividadVO.setDuracion(res.getString(4));
                actividadVO.setFechaInicio(res.getDate(5));
                actividadVO.setRecursoAsignado(res.getString(6));
                listaActividades.add(actividadVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaActividades;
    }

    public List<EvaluacionProyectoVO> consultarItemEvaluacionProyecto(ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        List<EvaluacionProyectoVO> listaItemEvaluacionProyecto = new ArrayList<EvaluacionProyectoVO>();
        EvaluacionProyectoVO evaluacionProyectoVO;

        try {
            sql = "{call ITM_CONSULTAR_ITEM_EVALUACION_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                evaluacionProyectoVO = new EvaluacionProyectoVO();
                evaluacionProyectoVO.setIdItemEvaluacion(res.getInt(1));
                evaluacionProyectoVO.setIdCriterio(res.getInt(2));
                evaluacionProyectoVO.setNombreItem(res.getString(3));
                evaluacionProyectoVO.setNombreCriterio(res.getString(4));
                listaItemEvaluacionProyecto.add(evaluacionProyectoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaItemEvaluacionProyecto;
    }

    public String evaluarCalidadProyecgto(EvaluacionCalidadProyectoVO evaluacionCalidadProyectoVO) throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_EVALUAR_CALIDAD_PROYECTO(?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, evaluacionCalidadProyectoVO.getIdProyecto());
            callStmt.setInt(3, evaluacionCalidadProyectoVO.getIdFase());
            callStmt.setInt(4, evaluacionCalidadProyectoVO.getIdItemEvaluacion());
            callStmt.setString(5, evaluacionCalidadProyectoVO.getEstadoCumplimiento());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String evaluarItemProyecto(EvaluacionProyectoVO evaluacionProyectoVO) throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_EVALUAR_ITEM_PROYECTO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, evaluacionProyectoVO.getIdProyecto());
            callStmt.setInt(3, evaluacionProyectoVO.getIdItemEvaluacion());
            callStmt.setInt(4, evaluacionProyectoVO.getIdEscala());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public int ingresarActividad(ActividadProyectoVO actividadVO) throws SQLException {
        int idActividad = 0;

        try {
            sql = "{call ITM_INGRESAR_ACTIVIDAD(?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setInt(2, actividadVO.getIdProyecto());
            callStmt.setString(3, actividadVO.getNombreActividad());
            callStmt.setString(4, actividadVO.getDuracion());
            callStmt.setDate(5, actividadVO.getFechaInicio());
            callStmt.setInt(6, actividadVO.getIdPersona());
            callStmt.execute();
            idActividad = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return idActividad;
    }

    public int ingresarAvanceActividad(AvanceActividadVO avanceActividadVO) throws SQLException {
        int idAvance = 0;

        try {
            sql = "{call ITM_INGRESAR_AVANCE_ACTIVIDAD(?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setInt(2, avanceActividadVO.getIdActividad());
            callStmt.setString(3, avanceActividadVO.getPorcentajeAvance());
            callStmt.setDate(4, avanceActividadVO.getFechaInicioReal());
            callStmt.setDate(5, avanceActividadVO.getFechaFinalizacionReal());
            callStmt.setInt(6, avanceActividadVO.getIdPersona());
            callStmt.execute();
            idAvance = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return idAvance;
    }

    public String insertarCriterioProyecto(CriterioObservacionVO criterioObservacionVO,
            ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_INGRESAR_CRITERIO_OBSERVACION_PROYECTO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, criterioObservacionVO.getIdCriterio());
            callStmt.setLong(3, proyectoInvVO.getIdProyecto());
            callStmt.setDate(4, criterioObservacionVO.getFechaRegistro());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public int insertarFuenteFinanciacion(FuenteFinanciacionVO fuenteFinanVO) throws SQLException {
        int idFuenteFinanciacion = 0;

        try {
            sql = "{call ITM_GUARDAR_FUENTE_FINANCIACION(?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setString(2, fuenteFinanVO.getNombreFunete());
            callStmt.setString(3, fuenteFinanVO.getIdentificacionFuente());
            callStmt.setString(4, fuenteFinanVO.getDescripcionFunete());
            callStmt.setInt(5, fuenteFinanVO.getIdTipoFuente());
            callStmt.setString(6, fuenteFinanVO.getPersonaContacto());
            callStmt.setString(7, fuenteFinanVO.getTelefonoContacto());
            callStmt.setString(8, fuenteFinanVO.getCorreoContacto());
            callStmt.execute();
            idFuenteFinanciacion = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return idFuenteFinanciacion;
    }

    public String insertarFuenteProyecto(FuenteFinanciacionVO fuenteFinanVO, ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_INSERTAR_FUENTE_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, fuenteFinanVO.getIdFuente());
            callStmt.setLong(3, proyectoInvVO.getIdProyecto());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String insertarGrupoProyecto(GrupoInvestigacionVO grupoInvVO, ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_INSERTAR_GRUPO_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, grupoInvVO.getIdGrupo());
            callStmt.setLong(3, proyectoInvVO.getIdProyecto());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String insertarPersonaProyecto(PersonaVO personaVO, ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        String respuesta = "";

        try {
            sql = "{call ITM_INSERTAR_PERSONA_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, personaVO.getIdPersona());
            callStmt.setLong(3, proyectoInvVO.getIdProyecto());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String existePersonasProyecto(PersonaVO personaVO, ProyectoInvestigacionVO proyectoInvVO) throws ProyectoInvestigacionDAOException {
        try {
            sql = "{call PRC_ITM_EXISTE_PERSONA_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, proyectoInvVO.getIdProyecto());
            callStmt.setLong(3, Long.parseLong(personaVO.getIdPersona()));
            callStmt.execute();
            return callStmt.getString(1);
        } catch (SQLException ex) {
            Logger.getLogger(ProyectoInvestigacionDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new ProyectoInvestigacionDAOException("Error al consultar", ex);
        }
    }

    public List<ProyectoInvestigacionVO> consultarProyectos(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        List<ProyectoInvestigacionVO> listaproyectos = new ArrayList<ProyectoInvestigacionVO>();

        try {
            sql = "{call ITM_CONSULTAR_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, proyectoInvVO.getIdBusqueda());
            callStmt.setString(2, proyectoInvVO.getTituloProyecto());
            callStmt.setString(3, proyectoInvVO.getPalabrasClave());
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvVO = new ProyectoInvestigacionVO();
                proyectoInvVO.setIdProyecto(res.getInt(1));
                proyectoInvVO.setTituloProyecto(res.getString(2));
                proyectoInvVO.setFechaPresentacion(res.getDate(3));
                proyectoInvVO.setDuracion(res.getString(6));
                proyectoInvVO.setPalabrasClave(res.getString(7));
                proyectoInvVO.setElaboradoPor(res.getString(8));
                listaproyectos.add(proyectoInvVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaproyectos;
    }

    public String consultarEstadoProyecto(String idProyecto) throws SQLException {
        String estado = "";

        try {
            sql = "{call ITM_CONSULTAR_ESTADO_PROYECTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, idProyecto);
            callStmt.execute();
            estado = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return estado;
    }

    public List<PersonaVO> listaPersonasProyecto(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        List<PersonaVO> listaPersonas = new ArrayList<PersonaVO>();
        PersonaVO personaVO;

        try {
            sql = "{call ITM_LISTAR_PERSONAS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setIdPersona(res.getString(1));
                personaVO.setNombrePersona(res.getString(2));
                listaPersonas.add(personaVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaPersonas;
    }

    public List<CriterioObservacionVO> listarCriteriosObservacion() throws SQLException {
        List<CriterioObservacionVO> listarCriterios = new ArrayList<CriterioObservacionVO>();
        CriterioObservacionVO criterioObservacionVO;

        try {
            sql = "{call ITM_LISTA_CRITERIOS_OBSERVACION_PROYECTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                criterioObservacionVO = new CriterioObservacionVO();
                criterioObservacionVO.setNombreCriterio(res.getString(1));
                criterioObservacionVO.setIdCriterio(res.getInt(2));
                listarCriterios.add(criterioObservacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listarCriterios;
    }

    public List<FasesVO> listarFases() throws SQLException {
        List<FasesVO> listaFases = new ArrayList<FasesVO>();
        FasesVO fasesVO;

        try {
            sql = "{call ITM_LISTAR_FASES_EVALUACION_CALIDAD()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                fasesVO = new FasesVO();
                fasesVO.setIdFase(res.getInt(1));
                fasesVO.setNombreFase(res.getString(2));
                listaFases.add(fasesVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaFases;
    }

    public List<FuenteFinanciacionVO> listarFuenteFinanciacion() throws SQLException {
        List<FuenteFinanciacionVO> listaFuenteFinanciacion = new ArrayList<FuenteFinanciacionVO>();
        FuenteFinanciacionVO feunteFinanVO;

        try {
            sql = "{call ITM_LISTAR_FUENTES_FINANCIACION()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                feunteFinanVO = new FuenteFinanciacionVO();
                feunteFinanVO.setIdFuente(res.getInt(1));
                feunteFinanVO.setNombreFunete(res.getString(2));
                listaFuenteFinanciacion.add(feunteFinanVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaFuenteFinanciacion;
    }

    public List<PersonaVO> listarPersonaByRol(RolVO rolVO) throws SQLException {
        List<PersonaVO> listaCoInvestigadores = new ArrayList<PersonaVO>();
        PersonaVO personaVO;

        try {
            sql = "{call ITM_LISTAR_PERSONAS_POR_ROL(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, rolVO.getNombreRol());
            res = callStmt.executeQuery();

            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setIdPersona(res.getString(1));
                personaVO.setNombrePersona(res.getString(2));
                listaCoInvestigadores.add(personaVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaCoInvestigadores;
    }

    public List<TipoInvestigacionVO> listarTipoInvestigacion() throws SQLException {
        List<TipoInvestigacionVO> listaTipoInvestigacion = new ArrayList<TipoInvestigacionVO>();
        TipoInvestigacionVO tipoInvestigacionVO;

        try {
            sql = "{call ITM_LISTA_TIPO_PROYECTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                tipoInvestigacionVO = new TipoInvestigacionVO();
                tipoInvestigacionVO.setIdTipoInvestigacion(res.getInt(1));
                tipoInvestigacionVO.setTipoInvastigacion(res.getString(2));
                listaTipoInvestigacion.add(tipoInvestigacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaTipoInvestigacion;
    }

    public int consultarMaxIdProyecto() throws SQLException {
        int maxId = 0;

        try {
            sql = "{call ITM_CONSULTAR_MAXID_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.execute();
            maxId = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return maxId;
    }

    public int matricularContinuaProyecto(ProyectoInvestigacionVO proyectoInvVO) {
        int idProyecto = 0;

        try {
            sql = "{call ITM_MODIFICAR_PROYECTO(?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setLong(2, proyectoInvVO.getIdProyecto());
            callStmt.setString(3, proyectoInvVO.getResumenProyecto());
            callStmt.setString(4, proyectoInvVO.getPlanteamientoJustificacion());
            callStmt.setString(5, proyectoInvVO.getObjetivoGeneral());
            callStmt.setString(6, proyectoInvVO.getObjetivoEspecifico());
            callStmt.setString(7, proyectoInvVO.getMetodologiaPropuesta());
            callStmt.setString(8, proyectoInvVO.getImpactos());
            callStmt.setString(9, proyectoInvVO.getBibliografiasReferencia());
            callStmt.execute();
            idProyecto = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return idProyecto;
    }

    public int matricularProyecto(ProyectoInvestigacionVO proyectoInvVO, ConvocatoriaVO convocatoriaVO)
            throws SQLException {
        int idProyecto = 0;
        TipoInvestigacionVO tipoInvestigacionVO;

        try {
            sql = "{call ITM_MATRICULAR_PROYECTO(?,?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setLong(2, proyectoInvVO.getIdProyecto());
            callStmt.setString(3, proyectoInvVO.getTituloProyecto());
            callStmt.setDate(4, proyectoInvVO.getFechaPresentacion());
            callStmt.setInt(5, proyectoInvVO.getIdLinea());
            callStmt.setInt(6, proyectoInvVO.getIdTipoInvestigacion());
            callStmt.setString(7, proyectoInvVO.getDuracion());
            callStmt.setString(8, proyectoInvVO.getPalabrasClave());
            callStmt.setString(9, proyectoInvVO.getElaboradoPor());
            callStmt.setString(10, convocatoriaVO.getIdConvocatoria());
            callStmt.execute();
            idProyecto = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return idProyecto;
    }

    public int adjuntarArchivoProyecto(ArchivoVO archivoVO) throws SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_GUARDAR_ANEXO_PROYECTO(?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setInt(2, archivoVO.getIdModulo());
            callStmt.setString(3, archivoVO.getNombreArchivo());
            callStmt.setString(4, archivoVO.getDescripcion());
            callStmt.setString(5, archivoVO.getRutaArchivo());
            callStmt.setDate(6, archivoVO.getFechaArchivo());
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.printStackTrace();
        }

        return resultado;
    }

    public int adjuntarArchivoFinalizarCerrar(ArchivoVO archivoVO, String estado) throws SQLException {
        int resultado = 0;

        try {
            sql = "{call ITM_FINALIZAR_CERRAR_PROYECTO(?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.BIGINT);
            callStmt.setInt(2, archivoVO.getIdModulo());
            callStmt.setString(3, archivoVO.getNombreArchivo());
            callStmt.setString(4, archivoVO.getDescripcion());
            callStmt.setString(5, archivoVO.getRutaArchivo());
            callStmt.setDate(6, archivoVO.getFechaArchivo());
            callStmt.setString(7, estado);
            callStmt.execute();
            resultado = callStmt.getInt(1);
        } catch (Exception ce) {
            ce.printStackTrace();
        }

        return resultado;
    }

    public List<PersonaVO> consultarPersonasRolProyecto(ProyectoInvestigacionVO proyectoInvVO, String nombreRol)
            throws SQLException {
        List<PersonaVO> listaEstudiantes = new ArrayList<PersonaVO>();
        PersonaVO personaVO;

        try {
            sql = "{call ITM_CONSULTAR_PERSONAS_ROL_PROYECTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, nombreRol);
            callStmt.setLong(2, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setIdPersona(res.getString(1));
                personaVO.setNombrePersona(res.getString(2));
                listaEstudiantes.add(personaVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEstudiantes;
    }

    public List<FuenteFinanciacionVO> consultarFuenteFinanciacionProyecto(ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        List<FuenteFinanciacionVO> listaFuentes = new ArrayList<FuenteFinanciacionVO>();
        FuenteFinanciacionVO fuenteFinanVO;

        try {
            sql = "{call ITM_CONSULTAR_FUENTE_FINANCIACION_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                fuenteFinanVO = new FuenteFinanciacionVO();
                fuenteFinanVO.setIdFuente(res.getInt(1));
                fuenteFinanVO.setNombreFunete(res.getString(2));
                listaFuentes.add(fuenteFinanVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaFuentes;
    }

    public List<FuenteFinanciacionVO> consultarFuenteFinanciacionProyectoInt(int proyectoId) throws SQLException {
        List<FuenteFinanciacionVO> listaFuentes = new ArrayList<FuenteFinanciacionVO>();
        FuenteFinanciacionVO fuenteFinanVO;

        try {
            sql = "{call ITM_CONSULTAR_FUENTE_FINANCIACION_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setInt(1, proyectoId);
            res = callStmt.executeQuery();

            while (res.next()) {
                fuenteFinanVO = new FuenteFinanciacionVO();
                fuenteFinanVO.setIdFuente(res.getInt(1));
                fuenteFinanVO.setNombreFunete(res.getString(2));
                listaFuentes.add(fuenteFinanVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaFuentes;
    }

    public List<GrupoInvestigacionVO> consultarGruposProyecto(ProyectoInvestigacionVO proyectoInvVO)
            throws SQLException {
        List<GrupoInvestigacionVO> listaGrupos = new ArrayList<GrupoInvestigacionVO>();
        GrupoInvestigacionVO grupoInvVO;

        try {
            sql = "{call ITM_CONSULTAR_GRUPOS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                grupoInvVO = new GrupoInvestigacionVO();
                grupoInvVO.setIdGrupo(res.getInt(1));
                grupoInvVO.setNombreGrupo(res.getString(2));
                listaGrupos.add(grupoInvVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaGrupos;
    }

    public LineaInvestigacionVO consultarLineaProyecto(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        LineaInvestigacionVO lineainvVO = new LineaInvestigacionVO();

        try {
            sql = "{call ITM_CONSULTAR_LINEA_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            if (res.next()) {
                lineainvVO = new LineaInvestigacionVO();
                lineainvVO.setIdLinea(res.getInt(1));
                lineainvVO.setNombreLinea(res.getString(2));
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return lineainvVO;
    }

    public TipoInvestigacionVO consultarTipoProyecto(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        TipoInvestigacionVO tipoProyectoVO = new TipoInvestigacionVO();

        try {
            sql = "{call ITM_CONSULTAR_NOMBRE_TIPO_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            if (res.next()) {
                tipoProyectoVO = new TipoInvestigacionVO();
                tipoProyectoVO.setIdTipoInvestigacion(res.getInt(1));
                tipoProyectoVO.setTipoInvastigacion(res.getString(2));
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return tipoProyectoVO;
    }

    public ProyectoInvestigacionVO consultarProyectoById(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        try {
            sql = "{call ITM_CONSULTAR_PROYECTO_POR_ID(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            if (res.next()) {
                proyectoInvVO = new ProyectoInvestigacionVO();
                proyectoInvVO.setIdProyecto(res.getInt(1));
                proyectoInvVO.setTituloProyecto(res.getString(2));
                proyectoInvVO.setFechaPresentacion(res.getDate(3));
                proyectoInvVO.setDuracion(res.getString(6));
                proyectoInvVO.setPalabrasClave(res.getString(7));
                proyectoInvVO.setElaboradoPor(res.getString(8));
                proyectoInvVO.setResumenProyecto(res.getString(9));
                proyectoInvVO.setPlanteamientoJustificacion(res.getString(10));
                proyectoInvVO.setObjetivoGeneral(res.getString(11));
                proyectoInvVO.setObjetivoEspecifico(res.getString(12));
                proyectoInvVO.setMetodologiaPropuesta(res.getString(13));
                proyectoInvVO.setImpactos(res.getString(14));
                proyectoInvVO.setBibliografiasReferencia(res.getString(15));
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return proyectoInvVO;
    }

    public List<ArchivoVO> consultarArchivosProyecto(ProyectoInvestigacionVO proyectoInvVO) throws SQLException {
        List<ArchivoVO> listaArchivos = new ArrayList<ArchivoVO>();
        ArchivoVO archivoVO;

        try {
            sql = "{call ITM_CONSULTAR_ARCHIVOS_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                archivoVO = new ArchivoVO();
                archivoVO.setIdArchivoVO(res.getInt(1));
                archivoVO.setModulo(res.getString(2));
                archivoVO.setNombreArchivo(res.getString(3));
                archivoVO.setDescripcion(res.getString(4));
                archivoVO.setRutaArchivo(res.getString(5));
                archivoVO.setFechaArchivo(res.getDate(6));
                listaArchivos.add(archivoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaArchivos;
    }

    public List<EvaluacionProyectoVO> consultarEvaluacionProyecto(ProyectoInvestigacionVO proyectoInvVO) {
        List<EvaluacionProyectoVO> listaEvaluacion = new ArrayList<EvaluacionProyectoVO>();
        EvaluacionProyectoVO evaluacionProyectoVO;

        try {
            sql = "{call ITM_CONSULTAR_EVALUACION_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                evaluacionProyectoVO = new EvaluacionProyectoVO();
                evaluacionProyectoVO.setIdItemEvaluacion(res.getInt(1));
                evaluacionProyectoVO.setNombreItem(res.getString(2));
                evaluacionProyectoVO.setIdEscala(res.getInt(3));
                evaluacionProyectoVO.setIdCriterio(res.getInt(4));
                evaluacionProyectoVO.setNombreCriterio(res.getString(5));
                listaEvaluacion.add(evaluacionProyectoVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaEvaluacion;
    }

    public List<CriterioEvaluacionVO> consultarCriterioEvaluacionProyecto(ProyectoInvestigacionVO proyectoInvVO) {
        List<CriterioEvaluacionVO> listaCriterios = new ArrayList<CriterioEvaluacionVO>();
        CriterioEvaluacionVO criterioEvaluacionVO;

        try {
            sql = "{call ITM_CONSULTAR_CRITERIO_EVALUACION_PROYECTO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, proyectoInvVO.getIdProyecto());
            res = callStmt.executeQuery();

            while (res.next()) {
                criterioEvaluacionVO = new CriterioEvaluacionVO();
                criterioEvaluacionVO.setIdCriterio(res.getInt(1));
                criterioEvaluacionVO.setNombreCriterio(res.getString(2));
                listaCriterios.add(criterioEvaluacionVO);
            }
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return listaCriterios;
    }

    public String modificarEstadoProyecto(CriterioEstadoProyecto estadoProyectoVO) {
        String respuesta = "";

        try {
            sql = "{call ITM_MODIFICAR_ESTADO_PROYECTO(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, estadoProyectoVO.getIdProyecto());
            callStmt.setString(3, estadoProyectoVO.getEstado());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String rechazarProyecto(CriterioEstadoProyecto estadoProyectoVO) {
        String respuesta = "";

        try {
            sql = "{call ITM_RECHAZAR_PROYECTO(?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, estadoProyectoVO.getIdProyecto());
            callStmt.setString(3, estadoProyectoVO.getMotivoRechazo());
            callStmt.setDate(4, estadoProyectoVO.getFechaRechazo());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

    public String solicitarAval(ProyectoInvestigacionVO proyectoInvVO) {
        String respuesta = "";

        try {
            sql = "{call ITM_SOLICITAR_AVAL(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setInt(2, proyectoInvVO.getIdPersona());
            callStmt.setLong(3, proyectoInvVO.getIdProyecto());
            callStmt.execute();
            respuesta = callStmt.getString(1);
        } catch (Exception ce) {
            ce.getStackTrace();
        }

        return respuesta;
    }

     public int obtenerTiempoProyecto(long idProy) throws DAOException {
        int duracion = 0;
        try {
            sql = "{call PRC_ITM_OBTENER_TIEMPO_PROYECTO(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idProy);
            callStmt.registerOutParameter(2, java.sql.Types.BIGINT);
            callStmt.execute();
            duracion = callStmt.getInt(2);
            return duracion;
        } catch (SQLException ex) {
            Logger.getLogger(ProyectoInvestigacionDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar", ex);
        }
    }
}
